home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 49 / Amiga Format CD49 (2000-01-17)(Future Publishing)(GB)(Track 1 of 3)[!][issue 2000-02].iso / -serious- / comms / other / novia / src / nrc_server.c < prev    next >
Text File  |  1999-12-06  |  13KB  |  525 lines
  1. /*
  2. void FreeNRCList()
  3. {
  4.     struct Room *room;
  5.     struct Member *member;
  6.     if (room_list)
  7.     {
  8.         while (!IsListEmpty(room_list))
  9.         {
  10.             room=(Room *)room_list->lh_Head;
  11.             ClearList((List *)&room->Memberlist);
  12.             Remove((Node *)room);
  13.             FreeVec(room);
  14.         }
  15.         FreeVec(room_list);
  16.     }
  17. }
  18.  
  19. void LoadNRCList(List *rlist)
  20. {
  21.     BPTR mulder;
  22.     BPTR mulder2;
  23.     struct Member *member;
  24.     struct Room *room;
  25.     struct RoomMember *rm;
  26.     char buffer[80];
  27.     struct EClockVal eclock;
  28.     struct EClockVal eclock2;
  29.     ULONG ticks;
  30.     timeval tv;
  31.     double double1;
  32.     double double2;
  33.     sprintf(buffer,"%ssys.roomlist",cport->sysdirs->sysdata);
  34.  
  35.     ReadEClock(&eclock);
  36.     if (mulder=Open(buffer,MODE_OLDFILE))
  37.     {
  38.         char quit=FALSE;
  39.         ULONG ulong;
  40.         while (!IsListEmpty((List *)rlist))
  41.         {
  42.             Remove((Node *)rlist->lh_Head);
  43.             FreeVec(rlist->lh_Head);
  44.         }
  45.         roomcounter=0;
  46.         Writeio("Load NRC-Roomlist.\n",-1);
  47.         while (!quit && (room=AllocVec(sizeof(Room),MEMF_ANY)))
  48.         {
  49.             printf("room: %x\n",room);
  50.             if (Read(mulder,room,sizeof(Room))==sizeof(Room))
  51.             {
  52.                 NewList((List *)&room->userlist);
  53.                 NewList((List *)&room->Memberlist);
  54.                 room->members=0;
  55.                 sprintf(buffer,"work:novia/sysdata/sys.nrcmembers.%d",room->RoomID);
  56.                 LoadMemberList(buffer,(List *)&room->Memberlist);
  57.                 AddTail((List *)rlist,(Node *)room);
  58.                 roomcounter++;
  59.             }
  60.             else
  61.             {
  62.                 quit=TRUE;
  63.                 FreeVec(room);
  64.             }
  65.         }
  66.         Close(mulder);
  67.     }
  68.     else
  69.     {
  70.         Writeio("Can't load NRC-Roomlist. ",-1);
  71.         PrintDosError(IoErr());
  72.     }    
  73.     ticks=ReadEClock(&eclock2)/1000;
  74.     double1=(double)eclock.ev_lo;
  75.     double2=(double)eclock2.ev_lo;
  76.     ioprintf(" time=%f\n",(double2-double1)/(double)ticks);
  77. }
  78. */
  79. /*
  80. void EditNRCList(List *rlist)
  81. {
  82.     char quit=FALSE;
  83.     struct Room *room;
  84.     char nostdcmd;
  85.     char buffer[80];
  86.     ULONG cmdid;
  87.     ULONG ulong;
  88.     struct EClockVal eclock;
  89.     struct EClockVal eclock2;
  90.     ULONG ticks;
  91.     timeval tv;
  92.     double double1;
  93.     double double2;
  94.     ClearMemQuick(buffer,20);
  95.     if (IsListEmpty((List *)rlist))
  96.     {
  97.         Writeio("No Room's available.\n",-1);
  98.     }
  99.     else
  100.     {
  101.         room=(Room *)rlist->lh_Head;
  102.         while (room->ln_Succ)
  103.         {
  104.             ioprintf("RoomNo: %d, RoomName: %s, Users: %d\n",room->RoomID,room->RoomName,room->users);
  105.             room=room->ln_Succ;
  106.         }
  107.     }
  108.     Writeio("List, Edit...\n",-1);
  109.     while (!quit && !ProgramClose)
  110.     {
  111.         ioprintf("c3%d.root:services/nrc/> c7",cport->clientconfig.IDNumber);
  112.         Getstring(buffer,0,60,BUFFERED);
  113.         GetArg(buffer);
  114.         nostdcmd=TRUE;
  115.         switch(cmdid=GetCommandID(argstring[0]))
  116.         {
  117.             case CMD_QUIT:
  118.                 quit=TRUE;
  119.                 nostdcmd=FALSE;
  120.                 break;
  121.             case CMD_LIST:
  122.                 if (IsListEmpty((List *)rlist))
  123.                 {
  124.                     Writeio("No Room's available.\n",-1);
  125.                 }
  126.                 else
  127.                 {
  128.                     room=(Room *)rlist->lh_Head;
  129.                     while (room->ln_Succ)
  130.                     {
  131.                         ioprintf("RoomNo: %d, RoomName: %s, Users: %d\n",room->RoomID,room->RoomName,room->users);
  132.                         room=room->ln_Succ;
  133.                     }
  134.                 }
  135.                 nostdcmd=FALSE;
  136.                 break;
  137.             case CMD_EDIT:
  138.                 if (StrToLong(argstring[1],(LONG *)&ulong))
  139.                 {
  140.                     if (IsListEmpty((List *)rlist))
  141.                     {
  142.                         Writeio("No Room's available.\n",-1);
  143.                     }
  144.                     else
  145.                     {
  146.                         room=(Room *)rlist->lh_Head;
  147.                         while (room->ln_Succ && (room->RoomID!=ulong))
  148.                         {
  149.                             room=room->ln_Succ;
  150.                         }
  151.                         if (room->RoomID==ulong && room->ln_Succ)
  152.                         {
  153.                             if (VDE(VDEID_NRC,(char *)room))
  154.                                 SaveNRC(room);
  155.                         }
  156.                         else
  157.                             ioprintf("invalid ChannelID.\n");
  158.  
  159.                     }
  160.                 }
  161.                 else
  162.                 {
  163.                     ioprintf("USAGE: Edit [RoomID #]\n");
  164.                 }
  165.                 nostdcmd=FALSE;
  166.                 break;
  167.             case CMD_ADD:
  168.                 if (room=AllocVec(sizeof(Room),MEMF_ANY|MEMF_CLEAR))
  169.                 {
  170.                     ioprintf("Name of Channel:");
  171.                     Getstring(buffer,0,39,0);
  172.                     strcpy(room->RoomName,buffer);
  173.                     room->RoomID=roomcounter++;
  174.                     if (VDE(VDEID_NRC,(char *)room))
  175.                     {
  176.                         NewList((List *)&room->userlist);
  177.                         NewList((List *)&room->Memberlist);
  178.                         AddTail((List *)rlist,(Node *)room);
  179.                         SaveNRC(room);
  180.                     }
  181.                     else
  182.                         FreeVec(room);
  183.                     
  184.                 }
  185.                 else
  186.                     ioprintf("Can't add room, out of memory.\n");
  187.                 nostdcmd=FALSE;
  188.                 break;
  189.             case CMD_DEL:
  190.                 if (StrToLong(argstring[1],(LONG *)&ulong))
  191.                 {
  192.                     if (IsListEmpty((List *)rlist))
  193.                     {
  194.                         Writeio("No Room's available.\n",-1);
  195.                     }
  196.                     else
  197.                     {
  198.                         room=(Room *)rlist->lh_Head;
  199.                         while (room->ln_Succ && (room->RoomID!=ulong))
  200.                         {
  201.                             room=room->ln_Succ;
  202.                         }
  203.                         if (room->RoomID==ulong && room->ln_Succ)
  204.                         {
  205.                             KillNRC(room);
  206.                         }
  207.                         else
  208.                             ioprintf("invalid ChannelID.\n");
  209.  
  210.                     }
  211.                 }
  212.                 else
  213.                 {
  214.                     ioprintf("USAGE: DELete [RoomID #]\n");
  215.                 }
  216.                 break;
  217.             case CMD_DELMEMBER:
  218.                 if (strlen(argstring[1]) && StrToLong(argstring[1],(LONG *)&ulong))
  219.                 {
  220.                     if (IsListEmpty((List *)rlist))
  221.                     {
  222.                         Writeio("No Room's available.\n",-1);
  223.                     }
  224.                     else
  225.                     {
  226.                         room=(Room *)rlist->lh_Head;
  227.                         while (room->ln_Succ && (room->RoomID!=ulong))
  228.                         {
  229.                             room=room->ln_Succ;
  230.                         }
  231.                         if (room->RoomID==ulong && room->ln_Succ)
  232.                         {
  233.                             if (ulong=FindUser(argstring[2]))
  234.                             {
  235.                                 BOOL userfound=FALSE;
  236.                                 struct Member *member;
  237.                                 member=(Member *)room->Memberlist.mlh_Head;
  238.                                 while (member->ln_Succ && !userfound)
  239.                                 {
  240.                                     if (member->UserID==ulong)
  241.                                     {
  242.                                         ioprintf("Remove User %s (%d) from %s ?",
  243.                                             cport->UL.utable[member->UserID].Handle,
  244.                                             cport->UL.utable[member->UserID].IDNumber,
  245.                                             room->RoomName);
  246.                                         if (Yesno(TRUE))
  247.                                         {
  248.                                             ioprintf("User %s (%d) in not longer a member of %s.\n",
  249.                                                 cport->UL.utable[member->UserID].Handle,
  250.                                                 cport->UL.utable[member->UserID].IDNumber,
  251.                                             room->RoomName);
  252.                                             Remove((Node *)member);
  253.                                             FreeVec(member);
  254.                                             SaveNRC(room);
  255.                                         }
  256.                                         userfound=TRUE;
  257.                                     }
  258.                                     else
  259.                                         member=member->ln_Succ;
  260.                                 }
  261.                                 if (!userfound)
  262.                                     ioprintf("User %s (%d) is not a member of %s.\n",
  263.                                         cport->UL.utable[ulong].Handle,
  264.                                         cport->UL.utable[ulong].IDNumber,
  265.                                         room->RoomName);
  266.                             }
  267.                             else
  268.                                 if (strlen(argstring[2]))
  269.                                     ioprintf("invalid User %s.\n",argstring[2]);
  270.                                 else
  271.                                     ioprintf("USAGE: DELMember [RoomID #],[UserID #|Username]\n");
  272.                         }
  273.                         else
  274.                             ioprintf("invalid ChannelID %d.\n",ulong);
  275.  
  276.                     }
  277.                 }
  278.                 else
  279.                 {
  280.                     ioprintf("USAGE: DELMember [RoomID #],[UserID #|Username]\n");
  281.                 }
  282.                 nostdcmd=FALSE;
  283.                 break;
  284.             case CMD_ADDMEMBER:
  285.                 if (strlen(argstring[1]) && StrToLong(argstring[1],(LONG *)&ulong))
  286.                 {
  287.                     if (IsListEmpty((List *)rlist))
  288.                     {
  289.                         Writeio("No Room's available.\n",-1);
  290.                     }
  291.                     else
  292.                     {
  293.                         room=(Room *)rlist->lh_Head;
  294.                         while (room->ln_Succ && (room->RoomID!=ulong))
  295.                         {
  296.                             room=room->ln_Succ;
  297.                         }
  298.                         if (room->RoomID==ulong && room->ln_Succ)
  299.                         {
  300.                             if (ulong=FindUser(argstring[2]))
  301.                             {
  302.                                 BOOL userfound=FALSE;
  303.                                 struct Member *member;
  304.                                 member=(Member *)room->Memberlist.mlh_Head;
  305.                                 while (member->ln_Succ && !userfound)
  306.                                 {
  307.                                     if (member->UserID==ulong)
  308.                                         userfound=TRUE;
  309.                                     else
  310.                                         member=member->ln_Succ;
  311.                                 }
  312.                                 if (userfound)
  313.                                     ioprintf("User %s (%d) is already a member of %s.\n",
  314.                                         cport->UL.utable[ulong].Handle,
  315.                                         cport->UL.utable[ulong].IDNumber,
  316.                                         room->RoomName);
  317.                                 else
  318.                                 {
  319.                                     if (member=AllocVec(sizeof(Member),MEMF_ANY))
  320.                                     {
  321.                                         member->UserID=ulong;
  322.                                         AddTail((List *)&room->Memberlist,(Node *)member);
  323.                                         ioprintf("User %s (%d) is now a member of %s.\n",
  324.                                             cport->UL.utable[ulong].Handle,
  325.                                             cport->UL.utable[ulong].IDNumber,
  326.                                             room->RoomName);
  327.                                             SaveNRC(room);
  328.                                     }
  329.                                     else
  330.                                         Writeio("Can't add user, out of memory.\n",-1);
  331.                                 }
  332.                             }
  333.                             else
  334.                                 if (strlen(argstring[2]))
  335.                                     ioprintf("invalid User %s.\n",argstring[2]);
  336.                                 else
  337.                                     ioprintf("USAGE: ADDMember [RoomID #],[UserID #|Username]\n");
  338.                         }
  339.                         else
  340.                             ioprintf("invalid ChannelID %d.\n",ulong);
  341.  
  342.                     }
  343.                 }
  344.                 else
  345.                 {
  346.                     ioprintf("USAGE: ADDMember [RoomID #],[UserID #|Username]\n");
  347.                 }
  348.                 nostdcmd=FALSE;
  349.                 break;
  350.             case CMD_MEMBERS: case CMD_LISTMEMBERS:
  351.                 if (*argstring[1]=='?')
  352.                     ioprintf("USAGE: MEMBERS/LISTMEMBERS [RoomID #].\n");
  353.                 else
  354.                 {
  355.                     if (IsListEmpty((List *)rlist))
  356.                     {
  357.                         Writeio("No Room's available.\n",-1);
  358.                     }
  359.                     else
  360.                     {
  361.                         struct Member *member;
  362.                         StrToLong(argstring[1],(LONG *)&ulong);
  363.                         if (ulong)
  364.                         {
  365.                             room=(Room *)rlist->lh_Head;
  366.                             while (room->ln_Succ && (room->RoomID!=ulong))
  367.                             {
  368.                                 room=room->ln_Succ;
  369.                             }
  370.                             if (room->RoomID==ulong && room->ln_Succ)
  371.                             {
  372.                                 member=(Member *)room->Memberlist.mlh_Head;
  373.                                 while (member->ln_Succ)
  374.                                 {
  375.                                     if (member->UserID>0 && member->UserID<=cport->UL.UserEntrys)
  376.                                         ioprintf("User: %21s (%d)\n",cport->UL.utable[member->UserID].Handle,member->UserID);
  377.                                     member=member->ln_Succ;
  378.                                 }
  379.                             }
  380.                             else
  381.                                 ioprintf("invalid ChannelID %d.\n",ulong);
  382.                         }
  383.                         else
  384.                         {
  385.                             room=(Room *)rlist->lh_Head;
  386.                             while (room->ln_Succ)
  387.                             {
  388.                                 ioprintf("c7Members in Room %s (%d):\n",room->RoomName,room->RoomID);
  389.                                 member=(Member *)room->Memberlist.mlh_Head;
  390.                                 if (member->ln_Succ)
  391.                                 {
  392.                                     while (member->ln_Succ)
  393.                                     {
  394.                                         if (member->UserID>0 && member->UserID<=cport->UL.UserEntrys)
  395.                                             ioprintf("c3   User: %21s (%d)\n",cport->UL.utable[member->UserID].Handle,member->UserID);
  396.                                         member=member->ln_Succ;
  397.                                     }
  398.                                 }
  399.                                 else
  400.                                     ioprintf("c1   (this room has no members)\n");
  401.                                 member=(Member *)room->Grouplist.mlh_Head;
  402.                                 if (member->ln_Succ)
  403.                                 {
  404.                                     while (member->ln_Succ)
  405.                                     {
  406.                                         if (member->UserID>0 && member->UserID<=cport->UL.UserEntrys)
  407.                                             ioprintf("c3   Group: %21s (%d)\n",cport->UL.utable[member->UserID].Handle,member->UserID);
  408.                                         member=member->ln_Succ;
  409.                                     }
  410.                                 }
  411.                                 else
  412.                                     ioprintf("c1   (this room has no membergroup)\n");
  413.                                 room=room->ln_Succ;
  414.                             }
  415.                         }
  416.  
  417.                     }
  418.                 }
  419.                 nostdcmd=FALSE;
  420.                 break;
  421.             case CMD_ADDGROUP:
  422.             {
  423. *//*                List list;
  424.                 struct Node *node;
  425.                 NewList(&list);
  426.                 ReadEClock(&eclock);
  427.                 for (ulong=0;ulong<100000;ulong++)
  428.                 {
  429.                     if (node=AllocVec(sizeof(Node),MEMF_ANY))
  430.                     {
  431.                         AddTail(&list,node);
  432.                     }
  433.                 }
  434.                 ticks=ReadEClock(&eclock2)/1000;
  435.                 double1=(double)eclock.ev_lo;
  436.                 double2=(double)eclock2.ev_lo;
  437.                 ioprintf("time=%f ms\n",(double2-double1)/(double)ticks);
  438.                 node=list.lh_Head;
  439.  
  440.                 ReadEClock(&eclock);
  441.                 while (node->ln_Succ)
  442.                     node=node->ln_Succ;
  443.                 ticks=ReadEClock(&eclock2)/1000;
  444.                 double1=(double)eclock.ev_lo;
  445.                 double2=(double)eclock2.ev_lo;
  446.                 ioprintf("time=%f ms\n",(double2-double1)/(double)ticks);
  447.  
  448. *//*                ReadEClock(&eclock);
  449. //                while (list.lh_Head->ln_Succ)
  450. //                    FreeVec(RemTail(&list));
  451.                 ticks=ReadEClock(&eclock2)/1000;
  452.                 double1=(double)eclock.ev_lo;
  453.                 double2=(double)eclock2.ev_lo;
  454.                 ioprintf("time=%f ms\n",(double2-double1)/(double)ticks);
  455.  
  456.             }
  457.                 nostdcmd=FALSE;
  458.                 break;
  459.             case CMD_DELGROUP:
  460.                 nostdcmd=FALSE;
  461.                 break;
  462.         }
  463.         if (nostdcmd)
  464.         {    
  465.             if (!StdCommand(cmdid) && strlen(argstring[0]))
  466.             {
  467.                 ioprintf("%s: Unknown command\n",argstring[0]);
  468.                 ShowText("work:novia/systext/sys.nrc");LF();
  469.             }
  470.         }        
  471.     }
  472. }
  473.  
  474. void SaveNRCList(List *rlist)
  475. {
  476.     struct Room *room=(Room *)rlist->lh_Head;
  477.     Execute("delete work:novia/sysdata/sys.roomlist",0,0);
  478.     while (room->ln_Succ)
  479.     {
  480.         SaveNRC(room);
  481.         room=room->ln_Succ;
  482.     }    
  483.  
  484. }
  485.  
  486. void LoadNRC(struct Room *room)
  487. {
  488. }
  489.  
  490. void KillNRC(struct Room *room)
  491. {
  492.     struct Member *member;
  493.     char buffer[100];
  494.     sprintf(buffer,"delete work:novia/sysdata/sys.nrcmembers.%d",room->RoomID);
  495.     Execute(buffer,0,0);
  496.     while (!IsListEmpty((List *)&room->Memberlist))
  497.         FreeVec(RemHead((List *)&room->Memberlist.mlh_Head));
  498.     Remove((Node *)room);
  499.     FreeVec(room);
  500.  
  501.     SaveNRCList(room_list);
  502. }
  503.  
  504. void SaveNRC(struct Room *room)
  505. {
  506.     char buffer[100];
  507.     BPTR mulder=Open("work:novia/sysdata/sys.roomlist",MODE_READWRITE);
  508.     struct RoomMember *rm;
  509.     if (mulder)
  510.     {
  511.         BPTR mulder2;
  512.         sprintf(buffer,"work:novia/sysdata/sys.nrcmembers.%d",room->RoomID);
  513.         SaveMemberList(buffer,(List *)&room->Memberlist);
  514.         Seek(mulder,sizeof(Room)*(room->RoomID-1),OFFSET_BEGINNING);
  515.         Write(mulder,room,sizeof(Room));
  516.         Close(mulder);
  517.     }    
  518.     else
  519.     {
  520.         ioprintf("Can't write NRC-Room: %d. ",room->RoomID);
  521.         PrintDosError(IoErr());
  522.     }    
  523. }
  524. */
  525.